/* ts内置工具 */

// 1.Partial<T>
// 作用：将类型 T 的所有属性变为可选（?）
interface Res {
    status: number;
    data: string
}
type PartialRes = Partial<Res>;
// 等价于：{ status?: number; data?: string }


// 2.Required<T>
// 作用：与 Partial 相反，将类型 T 的所有可选属性变为必填
interface Opt {
    a?: number;
    b?: string
}
type RequiredOpt = Required<Opt>;
// 等价于：{ a: number; b: string }


// 3. Readonly<T>
// 作用：将类型 T 的所有属性变为只读（readonly），无法重新赋值
interface User1 {
    name: string
}
type ReadonlyUser = Readonly<User1>;
// 等价于：{ readonly name: string }
const u: ReadonlyUser = { name: "Tom" };
// u.name = "Jerry";  => 报错：属性只读


// 4. Record<K, T>
// 作用：创建一个对象类型，键为 K 类型，值为 T 类型（常用于定义 “键值对” 结构）
type Key = "a" | "b";
type Value = number;
type RecordType = Record<Key, Value>;
// 等价于：{ a: number; b: number }


// 5. Pick<T, K>
// 作用：从类型 T 中 “挑选” 部分属性 K（K 必须是 T 的属性键），组成新类型
interface User {
    id: number;
    name: string;
    age: number
}
type PickUser = Pick<User, "name" | "age">;
// 等价于：{ name: string; age: number }


// 6. Omit<T, K>
// 作用：与 Pick 相反，从类型 T 中 “排除” 部分属性 K，保留剩余属性
interface User {
    id: number;
    name: string;
    age: number
}
type OmitUser = Omit<User, "id">;
// 等价于：{ name: string; age: number }


// 7. Exclude<T, U>
// 作用：从联合类型 T 中排除与 U 类型重叠的部分（仅用于联合类型）
type T = "a" | "b" | "c";
type U = "a" | "d";
type ExcludeType = Exclude<T, U>; // 结果："b" | "c"


// 8. Extract<T, U>
// 作用：与 Exclude 相反，从联合类型 T 中保留与 U 类型重叠的部分
type T1 = "a" | "b" | "c";
type U1 = "a" | "d";
type ExtractType = Extract<T1, U1>; // 结果："a"


// 9. ReturnType<T>
// 作用：获取函数类型 T 的返回值类型
type Fn = (x: number) => string;
type Return = ReturnType<Fn>; // 结果：string


// 10. Parameters<T>
// 作用：获取函数类型 T 的参数类型，返回一个元组类型
type Fn1 = (name: string, age: number) => void;
type Params = Parameters<Fn1>; // 结果：[name: string, age: number]


// 11. NonNullable<T>
// 作用：从类型 T 中排除 null 和 undefined
type T2 = string | null | undefined;
type NonNull = NonNullable<T2>; // 结果：string


// 12. ThisParameterType<T>
// 作用：提取函数类型 T 中 this 的类型（若未指定 this，则返回 unknown）
type Fn2 = (this: { x: number }, y: number) => void;
type ThisType2 = ThisParameterType<Fn2>; // 结果：{ x: number }


// 13. OmitThisParameter<T>
// 作用：移除函数类型 T 中的 this 参数，返回一个不包含 this 的新函数类型
type Fn3 = (this: { x: number }, y: number) => void;
type OmitThis = OmitThisParameter<Fn3>; // 结果：(y: number) => void